home *** CD-ROM | disk | FTP | other *** search
/ X User Tools / X User Tools (O'Reilly and Associates)(1994).ISO / sources / spacebar / spatches < prev   
Text File  |  1994-09-27  |  11KB  |  327 lines
  1. The diffs below are patches to the MIT X11R5 server source that allow
  2. you to use the spacebar of your keyboard both as a spacebar and as a
  3. control key--if you press and release it you get a space, but if you
  4. press it and hold it down while pressing other keys, it acts like the
  5. Ctrl key.
  6.  
  7. The patches are short; they are at the end of this message.  The
  8. following paragraphs explain the patches.  I've also placed this file on
  9. export.lcs.mit.edu. It is available for anonymous ftp as
  10. contrib/spacebar_hack.patches.
  11.  
  12. BUT WHY?
  13.  
  14. I've begun to have discomfort typing; it is worst twisting my wrist side
  15. to side to hit Return, Backspace, and Ctrl.  I've been training myself
  16. to use Ctrl-H instead of Backspace and Ctrl-J instead of Return, but
  17. that still leaves the Ctrl key to contend with (I'm an emacs user, so I
  18. have to use Ctrl a lot).  I've been researching alternative keyboards,
  19. and was impressed with the Kinesis keyboard which has a number of thumb
  20. buttons other than a space bar.  By default these buttons are bound to
  21. Return, Backspace, and other frequently used keys that require
  22. stretching.  I decided to see if I could simulate some of this in
  23. software.  Now that I can use my spacebar as a Ctrl key, I rarely have
  24. to stretch my wrists from side to side.  I'm releasing the patches for
  25. anyone else who finds them useful.
  26.  
  27. HOW WELL DOES IT WORK?
  28.  
  29. It reduces the discomfort I feel while typing, which was my primary
  30. goal.  It took me only a day or so to train myself to use this new Ctrl
  31. key.  A bigger problem, though is learning that when I want a Space
  32. character I've got to fully release the spacebar before typing the next
  33. character, or I'll get a control character instead.  For example, in
  34. emacs, if I try to type the words "about the" too quickly I get
  35. "abotuhe"--the " t" turns into a Ctrl-t which transposes the last two
  36. charaters of "about", and then I type "he".  It took me three or four
  37. days to get used to this, and I still do it sometime.  I don't know if
  38. this is a typing habit that other people would have as well, or if it is
  39. just something about the way I type.
  40.  
  41. This patch does seem to introduce a bug:  with this server running, I
  42. can still select text in xterm, but once selected, the text does not
  43. remain highlighted.  It can still be pasted, but you just don't get a
  44. visual indication of what text is selected in xterm.  I've got no clue
  45. why this is happening, and haven't tried to track it down; the bug
  46. doesn't bother me enough to worry about it.
  47.  
  48. I've only tried building this patch on a Sun 3 with SunOS 4.1.  It is a
  49. very short patch, and does not touch any of the device-dependent code in
  50. the server, so I expect that it should be portable to most
  51. architectures. 
  52.  
  53. I hope that you find this patch useful, but please don't ask me to
  54. provide support for it--I'm not an X server guru, and have too many
  55. other things to be working on.  The patch is provides as-is, of course,
  56. and without warranties of any kind.
  57.  
  58. HOW DO I PATCH MY SERVER?
  59.  
  60. To apply the diffs in this message to your server sources, run them
  61. through the patch program.  Do something like this:
  62.  
  63.     cd /usr/X11R5/mit
  64.     patch < keyhack.patches
  65.  
  66. Only two files are changed:  server/dix/events.c and server/os/utils.c
  67.  
  68. If your build tree hasn't been cleaned up, you may be able to rebuild
  69. the server by doing the following:
  70.  
  71.     cd server
  72.     make
  73.  
  74. But probably you'll have to do something like:
  75.  
  76.     make Makefiles
  77.     make includes
  78.     cd server
  79.     make
  80.  
  81. If you can't figure this out, talk to whoever it was that built your
  82. server to begin with.
  83.  
  84. Before installing the new server, you probably want to mv your old
  85. server to some other name.  Don't overwrite it, in case you don't like
  86. using these patches.
  87.  
  88. HOW DO I USE IT?
  89.  
  90. The new server you have just built will behave just like your old
  91. server, unless you start it with the -keyhack option.  The keyhack
  92. option takes two integer arguments: the keycode of the spacebar and the
  93. keycode of the ctrl key.  There is probably some portable way to figure
  94. this out within the X server, but I didn't know what it was, and since I
  95. didn't want to hardcode these numbers into the patch, you have to supply
  96. them on the command line.  You can figure out the keycodes for these
  97. keys with the following command which prints the keycodes for each key
  98. on your keyboard.
  99.  
  100.     xmodmap -pk | more
  101.  
  102. So, for example, I start up my server with the command:
  103.  
  104.     Xsun -zaphod -keyhack 128 83
  105.  
  106. (-zaphod is a Sun-specific option; nothing to do with this patch.)
  107.  
  108. I use xinit to start up my server, and since I don't want to type these
  109. options every time, I've created a ~/.xserverrc file with this line in
  110. it:
  111.  
  112. /usr/bin/X11/Xsun -zaphod -keyhack 128 83
  113.  
  114. If you use xdm to start up your server, there is presumably a similar
  115. configuration file you can use, but I don't know what it is.
  116.  
  117. Once you've started up the server, the spacebar hack will be active.  If
  118. someone else sits down at your machine, however, you may want to turn it
  119. off for them.  Part of this patch is to make the server respond to the
  120. SIGUSR2 signal.  If you do:
  121.  
  122.     kill -USR2 <pid>
  123.  
  124. you can turn this spacebar feature on and off.  <pid> in the above
  125. refers to the process id of the server. You'll have to do a 'ps a' to
  126. find it, or a 'ps aux' if the server was started by xdm rather than by
  127. you.  
  128.  
  129. Note that since the -keyhack argument takes two arbitrary keycodes, you
  130. could use this patch to make your Return key act like Return and Meta,
  131. or whatever else.
  132.  
  133. TODO
  134.  
  135. The right way to have introduced this functionality would really have
  136. been as a server extension, probably integrated with the X Input
  137. extension in some way.  Then there could be extended protocol requests
  138. to turn the feature on and off, instead of relying on a SIGUSR2, and
  139. there would presumably be a way to not have to pass keycodes on the
  140. command line.  I'll leave these changes to someone who is more familiar
  141. with the X server internals than I am.
  142.  
  143. Share and enjoy!
  144.  
  145.     David Flanagan
  146.     david@ora.com
  147.  
  148.  
  149. Patches are below this line.
  150. ----------------------------------------------------------------------
  151. *** server/dix/events.c.orig    Wed Jun  2 22:27:40 1993
  152. --- server/dix/events.c    Sun Jul  4 18:42:53 1993
  153. ***************
  154. *** 1813,1818 ****
  155. --- 1813,1822 ----
  156.       }
  157.   }
  158.   
  159. + int hack_space_keycode;  /* set from the command line */  
  160. + int hack_ctrl_keycode;
  161. + int keyhack_on;
  162. + 
  163.   void
  164.   ProcessKeyboardEvent (xE, keybd, count)
  165.       register xEvent *xE;
  166. ***************
  167. *** 1827,1832 ****
  168. --- 1831,1838 ----
  169.       GrabPtr         grab = keybd->grab;
  170.       Bool            deactivateGrab = FALSE;
  171.       register KeyClassPtr keyc = keybd->key;
  172. +     static int state;  /* state for a simple FSM */
  173. +     int oldkey;
  174.   
  175.       if (!syncEvents.playingEvents)
  176.       NoticeTime(xE)
  177. ***************
  178. *** 1841,1846 ****
  179. --- 1847,1901 ----
  180.       switch (xE->u.u.type)
  181.       {
  182.       case KeyPress: 
  183. +         if (keyhack_on) {
  184. +         switch (state) {
  185. +         case 0:
  186. +             /* eat space down events and go to state 1.
  187. +              * process all other key presses normally.
  188. +              * If Ctrl is already down, treat space normally.
  189. +              * this is a special case for Ctrl-Space, used in emacs.
  190. +              */
  191. +             if ((key == hack_space_keycode) &&
  192. +             !(keyc->state & ControlMask))
  193. +             {
  194. +             state = 1;
  195. +             return;
  196. +             }
  197. +             break;
  198. +             
  199. +         case 1:
  200. +             /* send a Ctrl-down event, go to state 2 and
  201. +              * fall through to the next case.  Set state
  202. +              * to a meaningless value while recursing so we
  203. +              * don't get any special processing for the
  204. +              * synthesized events.
  205. +              */
  206. +             state = -1;
  207. +             oldkey = xE->u.u.detail;
  208. +             xE->u.u.detail = hack_ctrl_keycode;
  209. +             ProcessKeyboardEvent(xE, keybd, count);
  210. +             xE->u.u.detail = oldkey;
  211. +             state = 2;
  212. +             
  213. +         case 2:
  214. +             /*
  215. +              * pass any key down event through, but set the Ctrl
  216. +              * modifier on it.  We can set the Ctrl modifier by just
  217. +              * recomputing the state field of the event as we did
  218. +              * above.  This is in fact more general, and will work
  219. +              * with other modifier keys as well.  This works because
  220. +              * when we sent the fake Ctrl down event above, the
  221. +              * recursive call to ProcessKeyboardEvent will change
  222. +              * keyc->state.
  223. +              * The only time we leave this state is on a key up
  224. +              * event below.
  225. +              */
  226. +             xE->u.keyButtonPointer.state =
  227. +             (keyc->state | inputInfo.pointer->button->state);
  228. +             break;
  229. +         }
  230. +         }
  231. + 
  232.           if (*kptr & bit) /* allow ddx to generate multiple downs */
  233.           {   
  234.           if (!modifiers)
  235. ***************
  236. *** 1872,1877 ****
  237. --- 1927,1971 ----
  238.           }
  239.           break;
  240.       case KeyRelease: 
  241. +         if (keyhack_on) {
  242. +         switch (state) {
  243. +         case 0:
  244. +             /* key releases are handled normally in this state */
  245. +             break;
  246. +         case 1:
  247. +             /*
  248. +              * if we get a space up before any other key down
  249. +              * keystroke, then we send space up, down and return to
  250. +              * state 0.  Set state to a meaningless value while
  251. +              * recursing so we don't process our own fake events.
  252. +              */
  253. +             if (key == hack_space_keycode) {
  254. +             state = -1;
  255. +             xE->u.u.type = KeyPress;
  256. +             ProcessKeyboardEvent(xE, keybd, count);
  257. +             xE->u.u.type = KeyRelease;
  258. +             ProcessKeyboardEvent(xE, keybd, count);
  259. +             state = 0;
  260. +             return;
  261. +             }
  262. +             break;
  263. +         case 2:
  264. +             /*
  265. +              * if this is a space up, convert it to a Ctrl up, 
  266. +              * send it, and revert to state 0.  Otherwise, just
  267. +              * send it as is and stay in this state.
  268. +              */
  269. +             if (key == hack_space_keycode) {
  270. +             state = -1;
  271. +             xE->u.u.detail = hack_ctrl_keycode;
  272. +             ProcessKeyboardEvent(xE, keybd, count);
  273. +             state = 0;
  274. +             return;
  275. +             }
  276. +             break;
  277. +         }
  278. +         }
  279. + 
  280.           if (!(*kptr & bit)) /* guard against duplicates */
  281.           return;
  282.           inputInfo.pointer->valuator->motionHintWindow = NullWindow;
  283. *** server/os/utils.c.orig    Thu Jun  3 14:28:34 1993
  284. --- server/os/utils.c    Thu Jun  3 12:34:53 1993
  285. ***************
  286. *** 240,245 ****
  287. --- 240,252 ----
  288.       ddxUseMsg();
  289.   }
  290.   
  291. + SIGVAL
  292. + hacktoggle()
  293. + {
  294. +     extern int keyhack_on;
  295. +     keyhack_on = !keyhack_on;
  296. + }
  297. + 
  298.   /*
  299.    * This function parses the command line. Handles device-independent fields
  300.    * and allows ddx to handle additional fields.  It is not allowed to modify
  301. ***************
  302. *** 521,526 ****
  303. --- 528,550 ----
  304.               SyncOn++;
  305.           }
  306.   #endif
  307. +     else if (strcmp(argv[i], "-keyhack") == 0) {
  308. +         extern int hack_space_keycode;
  309. +         extern int hack_ctrl_keycode;
  310. +         extern int keyhack_on;
  311. + 
  312. +         if (i < argc-1) {
  313. +         hack_space_keycode = atoi(argv[++i]);
  314. +         hack_ctrl_keycode = atoi(argv[++i]);
  315. +         keyhack_on = 1;
  316. +         signal(SIGUSR2, hacktoggle);
  317. +         }
  318. +         else {
  319. +         fprintf(stderr,
  320. +             "-keyhack argument needs two integer values.\n");
  321. +         keyhack_on = 0;
  322. +         }
  323. +     }
  324.        else
  325.        {
  326.           UseMsg();
  327.